home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2005 October / PCWOCT05.iso / Software / FromTheMag / XAMPP 1.4.14 / xampp-win32-1.4.14-installer.exe / xampp / php / pear / HTML / QuickForm / element.php < prev    next >
Encoding:
PHP Script  |  2004-10-01  |  11.8 KB  |  463 lines
  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4: */
  3. // +----------------------------------------------------------------------+
  4. // | PHP version 4.0                                                      |
  5. // +----------------------------------------------------------------------+
  6. // | Copyright (c) 1997, 1998, 1999, 2000, 2001 The PHP Group             |
  7. // +----------------------------------------------------------------------+
  8. // | This source file is subject to version 2.0 of the PHP license,       |
  9. // | that is bundled with this package in the file LICENSE, and is        |
  10. // | available at through the world-wide-web at                           |
  11. // | http://www.php.net/license/2_02.txt.                                 |
  12. // | If you did not receive a copy of the PHP license and are unable to   |
  13. // | obtain it through the world-wide-web, please send a note to          |
  14. // | license@php.net so we can mail you a copy immediately.               |
  15. // +----------------------------------------------------------------------+
  16. // | Authors: Adam Daniel <adaniel1@eesus.jnj.com>                        |
  17. // |          Bertrand Mansion <bmansion@mamasam.com>                     |
  18. // +----------------------------------------------------------------------+
  19. //
  20. // $Id: element.php,v 1.31 2004/02/28 22:10:16 avb Exp $
  21.  
  22. require_once('HTML/Common.php');
  23.  
  24. /**
  25.  * Base class for form elements
  26.  * 
  27.  * @author       Adam Daniel <adaniel1@eesus.jnj.com>
  28.  * @author       Bertrand Mansion <bmansion@mamasam.com>
  29.  * @version      1.3
  30.  * @since        PHP4.04pl1
  31.  * @access       public
  32.  * @abstract
  33.  */
  34. class HTML_QuickForm_element extends HTML_Common
  35. {
  36.     // {{{ properties
  37.  
  38.     /**
  39.      * Label of the field
  40.      * @var       string
  41.      * @since     1.3
  42.      * @access    private
  43.      */
  44.     var $_label = '';
  45.  
  46.     /**
  47.      * Form element type
  48.      * @var       string
  49.      * @since     1.0
  50.      * @access    private
  51.      */
  52.     var $_type = '';
  53.  
  54.     /**
  55.      * Flag to tell if element is frozen
  56.      * @var       boolean
  57.      * @since     1.0
  58.      * @access    private
  59.      */
  60.     var $_flagFrozen = false;
  61.  
  62.     /**
  63.      * Does the element support persistant data when frozen
  64.      * @var       boolean
  65.      * @since     1.3
  66.      * @access    private
  67.      */
  68.     var $_persistantFreeze = false;
  69.     
  70.     // }}}
  71.     // {{{ constructor
  72.     
  73.     /**
  74.      * Class constructor
  75.      * 
  76.      * @param    string     Name of the element
  77.      * @param    mixed      Label(s) for the element
  78.      * @param    mixed      Associative array of tag attributes or HTML attributes name="value" pairs
  79.      * @since     1.0
  80.      * @access    public
  81.      * @return    void
  82.      */
  83.     function HTML_QuickForm_element($elementName=null, $elementLabel=null, $attributes=null)
  84.     {
  85.         HTML_Common::HTML_Common($attributes);
  86.         if (isset($elementName)) {
  87.             $this->setName($elementName);
  88.         }
  89.         if (isset($elementLabel)) {
  90.             $this->setLabel($elementLabel);
  91.         }
  92.     } //end constructor
  93.     
  94.     // }}}
  95.     // {{{ apiVersion()
  96.  
  97.     /**
  98.      * Returns the current API version
  99.      *
  100.      * @since     1.0
  101.      * @access    public
  102.      * @return    float
  103.      */
  104.     function apiVersion()
  105.     {
  106.         return 2.0;
  107.     } // end func apiVersion
  108.  
  109.     // }}}
  110.     // {{{ getType()
  111.  
  112.     /**
  113.      * Returns element type
  114.      *
  115.      * @since     1.0
  116.      * @access    public
  117.      * @return    string
  118.      */
  119.     function getType()
  120.     {
  121.         return $this->_type;
  122.     } // end func getType
  123.  
  124.     // }}}
  125.     // {{{ setName()
  126.  
  127.     /**
  128.      * Sets the input field name
  129.      * 
  130.      * @param     string    $name   Input field name attribute
  131.      * @since     1.0
  132.      * @access    public
  133.      * @return    void
  134.      */
  135.     function setName($name)
  136.     {
  137.         // interface method
  138.     } //end func setName
  139.     
  140.     // }}}
  141.     // {{{ getName()
  142.  
  143.     /**
  144.      * Returns the element name
  145.      * 
  146.      * @since     1.0
  147.      * @access    public
  148.      * @return    string
  149.      */
  150.     function getName()
  151.     {
  152.         // interface method
  153.     } //end func getName
  154.     
  155.     // }}}
  156.     // {{{ setValue()
  157.  
  158.     /**
  159.      * Sets the value of the form element
  160.      *
  161.      * @param     string    $value      Default value of the form element
  162.      * @since     1.0
  163.      * @access    public
  164.      * @return    void
  165.      */
  166.     function setValue($value)
  167.     {
  168.         // interface
  169.     } // end func setValue
  170.  
  171.     // }}}
  172.     // {{{ getValue()
  173.  
  174.     /**
  175.      * Returns the value of the form element
  176.      *
  177.      * @since     1.0
  178.      * @access    public
  179.      * @return    mixed
  180.      */
  181.     function getValue()
  182.     {
  183.         // interface
  184.         return null;
  185.     } // end func getValue
  186.     
  187.     // }}}
  188.     // {{{ freeze()
  189.  
  190.     /**
  191.      * Freeze the element so that only its value is returned
  192.      * 
  193.      * @access    public
  194.      * @return    void
  195.      */
  196.     function freeze()
  197.     {
  198.         $this->_flagFrozen = true;
  199.     } //end func freeze
  200.  
  201.     // }}}
  202.     // {{{ getFrozenHtml()
  203.  
  204.     /**
  205.      * Returns the value of field without HTML tags
  206.      * 
  207.      * @since     1.0
  208.      * @access    public
  209.      * @return    string
  210.      */
  211.     function getFrozenHtml()
  212.     {
  213.         $value = $this->getValue();
  214.         return ('' != $value? htmlspecialchars($value): ' ') .
  215.                $this->_getPersistantData();
  216.     } //end func getFrozenHtml
  217.     
  218.     // }}}
  219.     // {{{ _getPersistantData()
  220.  
  221.    /**
  222.     * Used by getFrozenHtml() to pass the element's value if _persistantFreeze is on
  223.     * 
  224.     * @access private
  225.     * @return string
  226.     */
  227.     function _getPersistantData()
  228.     {
  229.         if (!$this->_persistantFreeze) {
  230.             return '';
  231.         } else {
  232.             $id = $this->getAttribute('id');
  233.             return '<input type="hidden"' .
  234.                    (isset($id)? ' id="' . $id . '"': '') .
  235.                    ' name="' . $this->getName() . '"' .
  236.                    ' value="' . htmlspecialchars($this->getValue()) . '" />';
  237.         }
  238.     }
  239.  
  240.     // }}}
  241.     // {{{ isFrozen()
  242.  
  243.     /**
  244.      * Returns whether or not the element is frozen
  245.      *
  246.      * @since     1.3
  247.      * @access    public
  248.      * @return    bool
  249.      */
  250.     function isFrozen()
  251.     {
  252.         return $this->_flagFrozen;
  253.     } // end func isFrozen
  254.  
  255.     // }}}
  256.     // {{{ setPersistantFreeze()
  257.  
  258.     /**
  259.      * Sets wether an element value should be kept in an hidden field
  260.      * when the element is frozen or not
  261.      * 
  262.      * @param     bool    $persistant   True if persistant value
  263.      * @since     2.0
  264.      * @access    public
  265.      * @return    void
  266.      */
  267.     function setPersistantFreeze($persistant=false)
  268.     {
  269.         $this->_persistantFreeze = $persistant;
  270.     } //end func setPersistantFreeze
  271.  
  272.     // }}}
  273.     // {{{ setLabel()
  274.  
  275.     /**
  276.      * Sets display text for the element
  277.      * 
  278.      * @param     string    $label  Display text for the element
  279.      * @since     1.3
  280.      * @access    public
  281.      * @return    void
  282.      */
  283.     function setLabel($label)
  284.     {
  285.         $this->_label = $label;
  286.     } //end func setLabel
  287.  
  288.     // }}}
  289.     // {{{ getLabel()
  290.  
  291.     /**
  292.      * Returns display text for the element
  293.      * 
  294.      * @since     1.3
  295.      * @access    public
  296.      * @return    string
  297.      */
  298.     function getLabel()
  299.     {
  300.         return $this->_label;
  301.     } //end func getLabel
  302.  
  303.     // }}}
  304.     // {{{ _findValue()
  305.  
  306.     /**
  307.      * Tries to find the element value from the values array
  308.      * 
  309.      * @since     2.7
  310.      * @access    private
  311.      * @return    mixed
  312.      */
  313.     function _findValue(&$values)
  314.     {
  315.         if (empty($values)) {
  316.             return null;
  317.         }
  318.         $elementName = $this->getName();
  319.         if (isset($values[$elementName])) {
  320.             return $values[$elementName];
  321.         } elseif (strpos($elementName, '[')) {
  322.             $myVar = "['" . str_replace(array(']', '['), array('', "']['"), $elementName) . "']";
  323.             return eval("return (isset(\$values$myVar)) ? \$values$myVar : null;");
  324.         } else {
  325.             return null;
  326.         }
  327.     } //end func _findValue
  328.  
  329.     // }}}
  330.     // {{{ onQuickFormEvent()
  331.  
  332.     /**
  333.      * Called by HTML_QuickForm whenever form event is made on this element
  334.      *
  335.      * @param     string    $event  Name of event
  336.      * @param     mixed     $arg    event arguments
  337.      * @param     object    $caller calling object
  338.      * @since     1.0
  339.      * @access    public
  340.      * @return    void
  341.      */
  342.     function onQuickFormEvent($event, $arg, &$caller)
  343.     {
  344.         switch ($event) {
  345.             case 'createElement':
  346.                 $className = get_class($this);
  347.                 $this->$className($arg[0], $arg[1], $arg[2], $arg[3], $arg[4]);
  348.                 break;
  349.             case 'addElement':
  350.                 $this->onQuickFormEvent('createElement', $arg, $caller);
  351.                 $this->onQuickFormEvent('updateValue', null, $caller);
  352.                 break;
  353.             case 'updateValue':
  354.                 // constant values override both default and submitted ones
  355.                 // default values are overriden by submitted
  356.                 $value = $this->_findValue($caller->_constantValues);
  357.                 if (null === $value) {
  358.                     $value = $this->_findValue($caller->_submitValues);
  359.                     if (null === $value) {
  360.                         $value = $this->_findValue($caller->_defaultValues);
  361.                     }
  362.                 }
  363.                 if (null !== $value) {
  364.                     $this->setValue($value);
  365.                 }
  366.                 break;
  367.             case 'setGroupValue':
  368.                 $this->setValue($arg);
  369.         }
  370.         return true;
  371.     } // end func onQuickFormEvent
  372.  
  373.     // }}}
  374.     // {{{ accept()
  375.  
  376.    /**
  377.     * Accepts a renderer
  378.     *
  379.     * @param object     An HTML_QuickForm_Renderer object
  380.     * @param bool       Whether an element is required
  381.     * @param string     An error message associated with an element
  382.     * @access public
  383.     * @return void 
  384.     */
  385.     function accept(&$renderer, $required=false, $error=null)
  386.     {
  387.         $renderer->renderElement($this, $required, $error);
  388.     } // end func accept
  389.  
  390.     // }}}
  391.     // {{{ _generateId()
  392.  
  393.    /**
  394.     * Automatically generates and assigns an 'id' attribute for the element.
  395.     * 
  396.     * Currently used to ensure that labels work on radio buttons and
  397.     * checkboxes. Per idea of Alexander Radivanovich.
  398.     *
  399.     * @access private
  400.     * @return void 
  401.     */
  402.     function _generateId()
  403.     {
  404.         static $idx = 1;
  405.  
  406.         if (!$this->getAttribute('id')) {
  407.             $this->updateAttributes(array('id' => 'qf_' . substr(md5(microtime() . $idx++), 0, 6)));
  408.         }
  409.     } // end func _generateId
  410.  
  411.     // }}}
  412.     // {{{ exportValue()
  413.  
  414.    /**
  415.     * Returns a 'safe' element's value
  416.     *
  417.     * @param  array   array of submitted values to search
  418.     * @param  bool    whether to return the value as associative array
  419.     * @access public
  420.     * @return mixed
  421.     */
  422.     function exportValue(&$submitValues, $assoc = false)
  423.     {
  424.         $value = $this->_findValue($submitValues);
  425.         if (null === $value) {
  426.             $value = $this->getValue();
  427.         }
  428.         return $this->_prepareValue($value, $assoc);
  429.     }
  430.     
  431.     // }}}
  432.     // {{{ _prepareValue()
  433.  
  434.    /**
  435.     * Used by exportValue() to prepare the value for returning
  436.     *
  437.     * @param  mixed   the value found in exportValue()
  438.     * @param  bool    whether to return the value as associative array
  439.     * @access private
  440.     * @return mixed
  441.     */
  442.     function _prepareValue($value, $assoc)
  443.     {
  444.         if (null === $value) {
  445.             return null;
  446.         } elseif (!$assoc) {
  447.             return $value;
  448.         } else {
  449.             $name = $this->getName();
  450.             if (!strpos($name, '[')) {
  451.                 return array($name => $value);
  452.             } else {
  453.                 $valueAry = array();
  454.                 $myIndex  = "['" . str_replace(array(']', '['), array('', "']['"), $name) . "']";
  455.                 eval("\$valueAry$myIndex = \$value;");
  456.                 return $valueAry;
  457.             }
  458.         }
  459.     }
  460.     
  461.     // }}}
  462. } // end class HTML_QuickForm_element
  463. ?>